import os
import logging
import argparse
from datetime import datetime

# 导入自定义模块
from data_processor import DataProcessor
from statistics import DataStatistics

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler("app.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger('XHSCrawlerV3')


def create_directory(directory):
    """
    创建目录，如果不存在的话
    """
    if not os.path.exists(directory):
        os.makedirs(directory)
        logger.info(f"创建目录: {directory}")


def main():
    """
    主函数，执行完整的数据处理流程
    """
    # 解析命令行参数
    parser = argparse.ArgumentParser(description='小红书爬虫数据处理工具 V3')
    parser.add_argument('--data_dir', type=str, default='data', 
                      help='数据文件目录，默认为data')
    parser.add_argument('--results_dir', type=str, default='results', 
                      help='结果保存目录，默认为results')
    parser.add_argument('--config_file', type=str, default='.config', 
                      help='配置文件路径，默认为.config')
    
    args = parser.parse_args()
    
    # 获取绝对路径
    base_dir = os.path.dirname(os.path.abspath(__file__))
    data_dir = os.path.join(base_dir, '..', 'data')  # 使用上级目录的真实数据
    results_dir = os.path.join(base_dir, args.results_dir)
    config_file = os.path.join(base_dir, args.config_file)
    
    # 确保目录存在
    create_directory(data_dir)
    create_directory(results_dir)
    
    # 打印开始信息
    logger.info("="*80)
    logger.info(f"小红书爬虫数据处理工具 V3 开始运行")
    logger.info(f"开始时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    logger.info(f"数据目录: {data_dir}")
    logger.info(f"结果目录: {results_dir}")
    logger.info(f"配置文件: {config_file}")
    logger.info("="*80)
    
    # 初始化处理器
    try:
        data_processor = DataProcessor(data_dir, results_dir, config_file)
        statistics = DataStatistics(results_dir)
        
        # 步骤1: 合并笔记数据文件
        logger.info("\n=== 步骤1: 合并笔记数据文件 ===")
        note_merged_df = data_processor.merge_note_files()
        
        if note_merged_df.empty:
            logger.error("未获取到笔记数据，程序终止")
            return
        
        # 导出合并表
        data_processor.export_to_excel(note_merged_df, "笔记合并表.xlsx")
        
        # 调用统计功能，分析合并表
        logger.info("对笔记合并表进行统计分析...")
        statistics.run_complete_analysis(
            note_merged_df, 
            "笔记合并表"
        )
        
        # 步骤2: 清洗笔记数据
        logger.info("\n=== 步骤2: 清洗笔记数据 ===")
        note_initial_df = data_processor.clean_note_data(note_merged_df)
        
        if note_initial_df.empty:
            logger.error("笔记数据清洗后为空，程序终止")
            return
        
        # 导出笔记初始表
        data_processor.export_to_excel(note_initial_df, "笔记初始表.xlsx")
        
        # 调用统计功能，分析笔记初始表
        logger.info("对笔记初始表进行统计分析...")
        statistics.run_complete_analysis(
            note_initial_df, 
            "笔记初始表"
        )
        
        # 步骤3: 处理博主数据
        logger.info("\n=== 步骤3: 处理博主数据 ===")
        # 加载博主数据
        blogger_raw_df = data_processor.load_blogger_data()
        
        if blogger_raw_df.empty:
            logger.warning("未找到博主数据，将尝试从笔记数据中提取博主信息")
            # 尝试从笔记数据中提取博主信息
            if '博主ID' in note_initial_df.columns:
                # 创建简单的博主信息表
                blogger_cols = ['博主ID']
                if '博主昵称' in note_initial_df.columns:
                    blogger_cols.append('博主昵称')
                if '博主简介' in note_initial_df.columns:
                    blogger_cols.append('博主简介')
                if '粉丝数' in note_initial_df.columns:
                    blogger_cols.append('粉丝数')
                if '小红书号' in note_initial_df.columns:
                    blogger_cols.append('小红书号')
                
                blogger_raw_df = note_initial_df[blogger_cols].drop_duplicates(subset=['博主ID'])
                logger.info(f"从笔记数据中提取了 {len(blogger_raw_df)} 条博主信息")
            else:
                logger.error("无法从笔记数据中提取博主信息，程序终止")
                return
        
        # 清洗博主数据
        blogger_initial_df = data_processor.clean_blogger_data(blogger_raw_df)
        
        if blogger_initial_df.empty:
            logger.error("博主数据清洗后为空，程序终止")
            return
        
        # 导出博主初始表
        data_processor.export_to_excel(blogger_initial_df, "博主初始表.xlsx")
        
        # 调用统计功能，分析博主初始表
        logger.info("对博主初始表进行统计分析...")
        statistics.run_complete_analysis(
            blogger_initial_df, 
            "博主初始表"
        )
        
        # 步骤4: 合并笔记和博主数据
        logger.info("\n=== 步骤4: 合并笔记和博主数据 ===")
        merged_initial_df = data_processor.merge_note_and_blogger(
            note_initial_df, 
            blogger_initial_df
        )
        
        if merged_initial_df.empty:
            logger.error("笔记和博主数据合并失败，程序终止")
            return
        
        # 导出初始表
        data_processor.export_to_excel(merged_initial_df, "初始表.xlsx")
        
        # 调用统计功能，分析初始表
        logger.info("对初始表进行统计分析...")
        statistics.run_complete_analysis(
            merged_initial_df, 
            "初始表"
        )
        
        # 步骤5: 筛选基本表
        logger.info("\n=== 步骤5: 筛选基本表 ===")
        basic_table_df = data_processor.filter_basic_table(merged_initial_df)
        
        if basic_table_df.empty:
            logger.error("基本表筛选失败，程序终止")
            return
        
        # 导出基本表
        data_processor.export_to_excel(basic_table_df, "基本表.xlsx")
        
        # 调用统计功能，分析基本表
        logger.info("对基本表进行统计分析...")
        statistics.run_complete_analysis(
            basic_table_df, 
            "基本表"
        )
        
        # 打印完成信息
        logger.info("\n="*40)
        logger.info("数据处理流程全部完成！")
        logger.info(f"结束时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        logger.info(f"结果文件保存在: {results_dir}")
        logger.info("="*80)
        
    except Exception as e:
        logger.error(f"程序运行出错: {str(e)}", exc_info=True)
        raise


if __name__ == "__main__":
    main()